package com.tedu.api.list;

import org.junit.Test;
import java.util.*;

/**Collection集下  子集合【叫队列】
 * Queue   队列   单端队列
 * Deque   队列   双端队列  ”Deque接口--继承--Queue接口“
 *作用：保存数据，有序存储和处理，功能：数据缓冲或者多线程协调工作！
 *
 * 队列实现类
 * LinkedList：双向列表
 */
public class QueueAPI {
    @Test
    public void testQueue(){
        //Queue   队列   单端队列
        //创建队列 --多态 --LinkedList
        Queue<String> queue=new LinkedList<>();
        /**
         * offer() ---add()一样
         * 作用：入队操作，对尾追加元素
         */
        queue.offer("体面");
        queue.offer("青花瓷");
        queue.offer("不眠之夜");
        queue.offer("我的滑板鞋");
        queue.offer("在银河中孤独摇摆");
        System.out.println("Queue队列"+queue);
        /**
         * poll()   返回值：E
         * 作用：出队操作，获取队首元素，并且删除队列中队首
         * peek()   返回值：E
         * 作用：出队操作，获取队首元素，不删除队列中队首
         */
        queue.poll();//删除队首元素
        queue.poll();
        System.out.println("Queue队列："+queue);
        String str= queue.peek();
        System.out.println("队首元素："+str);
        System.out.println("Queue队列："+queue);
        /**
         * 需求：1.遍历队列，用while，只遍历一次队列【队列元素消失】
         * 提示：while 条件：拿到队列中的总长度 size()>0
         *      2.遍历队列，用增强for，队列元素不消失
         * 提示：for条件：E e ： 队列
         */

    }
    @Test
    public void testQueue2() {//while
        //Queue   队列   单端队列
        //创建队列 --多态 --LinkedList
        Queue<String> queue = new LinkedList<>();
        /**
         * offer() ---add()一样
         * 作用：入队操作，对尾追加元素
         */
        queue.offer("体面");
        queue.offer("青花瓷");
        queue.offer("不眠之夜");
        queue.offer("我的滑板鞋");
        queue.offer("在银河中孤独摇摆");
        while(queue.size()>0){ //true:队列总数>0 队列有元素 遍历
            String str=queue.poll();
            System.out.println("获取队列元素："+str);
        }
        System.out.println("queue队列元素："+queue);
    }
    @Test
    public void testQueue3() {//增强for
        //Queue   队列   单端队列
        //创建队列 --多态 --LinkedList
        Queue<String> queue = new LinkedList<>();
        /**
         * offer() ---add()一样
         * 作用：入队操作，对尾追加元素
         */
        queue.offer("体面");
        queue.offer("青花瓷");
        queue.offer("不眠之夜");
        queue.offer("我的滑板鞋");
        queue.offer("在银河中孤独摇摆");
        for (String str:queue){//增强for--底层Iterator遍历
            System.out.println("队列元素"+str);
        }
        System.out.println("queue队列"+queue);
    }
    //Deque  队列   双端队列---继承---单端队列
    @Test
    public void testDeque(){
        //创建Deque  双端队列  方法基本一致，部分方法不一致
        Deque<String> deque=new LinkedList<>();
        deque.offer("任贤齐");deque.offer("王菲");
        deque.offer("毛阿敏");deque.offer("那英");
        System.out.println("双端队列"+deque);
        //offerFirst() 队首添加元素
        //offerLast()  队尾添加元素
        deque.offerFirst("蔡徐坤");deque.offerLast("薛之谦");
        System.out.println("双端队列[首尾添加元素]："+deque);
        //getFirst() 获取队首   getList()  获取队尾   【与单端队列peek类似】
        System.out.println("获取队列中队首："+deque.getFirst());
        System.out.println("获取队列中队尾："+deque.getLast());
        //pollFirst() 获取队首，删除队列中队首 【与单端队列中poll类似】
        //pollLast()  获取队尾，删除队列中队尾
        String xue=deque.pollFirst();//删除“薛之谦”元素  队列--队首
        System.out.println("队尾元素"+xue);
        System.out.println("双端队列"+deque);
    }
    /**
     * 栈结构：业务中如果有后退【撤销】情况使用
     * 双端队列支持栈结构---提供相应方法实现栈结构
     */
    @Test
    public void testStack(){
        Deque<String> stack=new LinkedList<>();
        /**
         * push()  Deque  独有的方法--支持栈结构
         * ---offer:Queue---add:Collection接口 【添加】
         * 作用：【添加：往栈压入一个元素】 压栈操作
         */
        stack.push("夯大力");
        stack.push("恶搞之家");
        stack.push("喜羊羊与灰太狼");
        stack.push("魔方大厦");
        System.out.println("栈结构:"+stack);
        /**
         * pop()  出栈一个元素  --pollLast类似【先入后出，最后一个压栈元素】
         */
        String last=stack.pop();
        System.out.println("出栈尾元素："+last);
        System.out.println("栈结构:"+stack);
        //面试题：pop、poll、peek的使用区别
        /**
         * pop()  出栈一个元素  --pollLast类似【先入后出，最后一个压栈元素】
         * poll()   返回值：E
         *          作用：出队操作，获取队首元素，并且删除队列中队首
         * peek()   返回值：E
         *          作用：出队操作，获取队首元素，不删除队列中队首
         *pop 和 poll，删除并返回栈顶（队首）元素，
         *而peek，仅返回栈顶元素 pop栈结构，
         *后进先出，删除并返回第一个元素（栈顶），
         *栈顶为null值时抛出异常 poll是队列结构，
         *删除并返回第一个元素（队首），
         *队首为null时，返回null
         */
        /**
         * 需求1：遍历一个栈结构，用while遍历，实现元素出栈以后，队列元素清空
         * 需求2：遍历栈结构，用增强for，元素遍历成功后，队列元素不变
         */
    }
    @Test
    public void testStack2() {//while
        Deque<String> stack = new LinkedList<>();
        stack.push("夯大力");
        stack.push("恶搞之家");
        stack.push("喜羊羊与灰太狼");
        stack.push("魔方大厦");
        System.out.println("栈结构:"+stack);
        while(stack.size()>0){
            String str = stack.pop();
            System.out.println("遍历："+str);
        }
        System.out.println("删除以后的栈结构:"+stack);
    }
    @Test
    public void testStack3() {//while
        Deque<String> stack = new LinkedList<>();
        stack.push("夯大力");
        stack.push("恶搞之家");
        stack.push("喜羊羊与灰太狼");
        stack.push("魔方大厦");
        for (String str:stack){//增强for--底层Iterator遍历
            System.out.println("遍历："+str);
        }
        System.out.println("栈结构："+stack);
    }
}
